home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2007 December / PCWKCD1207B.iso / Blogowanie poza sfera / Flock 0.9.1.3 stable / flock-0.9.1.3.en-US.win32.exe / flock / components / flockFavoritesService.js < prev    next >
Text File  |  2007-10-12  |  57KB  |  1,766 lines
  1. // BEGIN FLOCK GPL
  2. // 
  3. // Copyright Flock Inc. 2005-2007
  4. // http://flock.com
  5. // 
  6. // This file may be used under the terms of of the
  7. // GNU General Public License Version 2 or later (the "GPL"),
  8. // http://www.gnu.org/licenses/gpl.html
  9. // 
  10. // Software distributed under the License is distributed on an "AS IS" basis,
  11. // WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12. // for the specific language governing rights and limitations under the
  13. // License.
  14. // 
  15. // END FLOCK GPL
  16. //
  17.  
  18. // XPConnect Helpers
  19. var Cc = Components.classes;
  20. var Ci = Components.interfaces;
  21. var Cr = Components.results;
  22.  
  23.  
  24. // Constants 
  25. const FAVORITES_RDF_FILE           = "flock-data.rdf";
  26. const OLD_FAVORITES_RDF_FILE       = "flock_favorites.rdf";
  27. const OLD_FAVORITES_RDF_FILE_RELIC = "flock_favorites_old.rdf";
  28. const FAVORITES_CID                = Components.ID("{3606f63a-f874-42fa-8174-cc9a0dd0a712}");
  29.  
  30. // Contract IDs
  31. const FAVORITES_CONTRACTID     = "@flock.com/favorites-service;1";
  32. const CONTAINER_CONTRACTID     = "@mozilla.org/rdf/container;1";
  33. const DIRECTORY_SVC_CONTRACTID = "@mozilla.org/file/directory_service;1";
  34. const LOCAL_FILE_CONTRACTID    = "@mozilla.org/file/local;1";
  35.  
  36. // Service handles
  37. const RDFS = Cc["@mozilla.org/rdf/rdf-service;1"].getService(Ci.nsIRDFService);
  38. const RDFCU = Cc["@mozilla.org/rdf/container-utils;1"].getService(Ci.nsIRDFContainerUtils);
  39. const PREFS = Cc["@mozilla.org/preferences-service;1"].getService(Ci.nsIPrefBranch);
  40. const IOS = Cc["@mozilla.org/network/io-service;1"].getService(Ci.nsIIOService);
  41.  
  42. // Namespaces Helpers
  43. function Namespace(ns) { return function (arg) { return RDFS.GetResource(ns+arg); } }
  44. const W3RDF  = Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#");
  45. const NSRDF  = Namespace("http://home.netscape.com/NC-rdf#");
  46. const WBRDF  = Namespace("http://home.netscape.com/WEB-rdf#");
  47. const FLRDF  = Namespace("http://flock.com/rdf#");
  48. const COLRDF = Namespace("urn:flock:collection:");
  49.  
  50. // RDF Properties
  51. const RDF_URL              = NSRDF("URL");
  52. const RDF_TAGS             = FLRDF("tags");
  53. const RDF_TAG              = FLRDF("tag");
  54. const RDF_WSID             = FLRDF("wsid");
  55. const RDF_NAME             = NSRDF("Name");
  56. const RDF_PERMISSIONS      = FLRDF("permissions");
  57. const RDF_TYPE             = W3RDF("type");
  58. const RDF_FAVORITE         = FLRDF("Favorite");
  59. const RDF_COLLECTION       = FLRDF("Collection");
  60. const RDF_FOLDER           = FLRDF("Folder");
  61. const RDF_LIVEMARK         = NSRDF("Livemark");
  62. const RDF_FEEDURL          = NSRDF("FeedURL");
  63. const RDF_FEEDENABLED      = FLRDF("feedEnabled");
  64. const RDF_SHORTCUTURL      = NSRDF("ShortcutURL");
  65. const RDF_DESCRIPTION      = NSRDF("Description");
  66. const RDF_NSYNC            = FLRDF("nsync");
  67. const RDF_LOCAL            = FLRDF("local");
  68. const RDF_LASTMODIFIEDDATE = WBRDF("LastModifiedDate");
  69. const RDF_LASTVISITDATE    = WBRDF("LastVisitDate");
  70. const RDF_ADDEDDATE        = FLRDF("FavoriteAddDate");
  71. const RDF_FAVORITESROOT    = FLRDF("BookmarksRoot");
  72. const RDF_COLLECTIONSROOT  = FLRDF("CollectionsRoot");
  73. const RDF_FOLDERSROOT      = FLRDF("FoldersRoot");
  74. const RDF_TAGSROOT         = FLRDF("TagsRoot");
  75. const RDF_INSTANCEOF       = W3RDF("instanceOf");
  76. const RDF_SEQ              = W3RDF("Seq");
  77. const RDF_FEED             = FLRDF("feed");
  78. const RDF_TOOLBAR          = FLRDF("toolbar");
  79. const RDF_STORE            = FLRDF("store");
  80. const RDF_VERSION          = FLRDF("version");
  81. const RDF_HASFEEDS         = FLRDF("hasFeeds");
  82. const RDF_ISFEED           = FLRDF("isFeed");
  83. const RDF_COOPTYPE         = FLRDF("CoopType");
  84.  
  85. // RDF Helpers
  86. var rdfLiteral = RDFS.GetLiteral;
  87. var rdfDate    = RDFS.GetDateLiteral;
  88. var rdfInt     = RDFS.GetIntLiteral;
  89. function rdfBoolean(b) { return rdfLiteral(b ? "true" : "false"); }
  90. const RDF_TRUE  = rdfBoolean(true);
  91. const RDF_FALSE = rdfBoolean(false);
  92.  
  93. // Prefs
  94. const PREF_INDEXED_INITIAL_FAVORITES = "flock.favorites.indexedInitialFavorites";
  95. const PREF_FIRSTRUN_COMPLETED        = "flock.firstrun.components.browser_startup.completed";
  96. const PREF_MYWORLD_TOPSITES_COUNT    = "flock.myworld.topsites.count";
  97. const PREF_MYWORLD_TOPSITES_COUNT_DEFAULT = 25;
  98.  
  99. const RECOUNT_INTERVAL = 500; // half-second delay in propagating count changes
  100.  
  101. // Cardinal migration
  102. const CARDINAL_BM_TOOLBAR_DEFAULT_NAME = "Favorites Toolbar";
  103.  
  104. function getObserverService() {
  105.   return Cc['@mozilla.org/observer-service;1']
  106.     .getService(Ci.nsIObserverService);
  107. }
  108.  
  109. // Remove Top Site
  110. function removeSite(aFolderURN, aResource, aCoopDS) {
  111.   var c_Folder = aCoopDS.get(aFolderURN);
  112.  
  113.   // Get Children of c_Folder
  114.   var childEnum = c_Folder.children.enumerate();
  115.  
  116.   // Get fav of aNewResource
  117.   aResource.QueryInterface(Ci.nsIRDFResource);
  118.   var fav = aCoopDS.get_from_resource(aResource);
  119.  
  120.   if(!fav) return;
  121.  
  122.   while (childEnum.hasMoreElements()) {
  123.     var child = childEnum.getNext();
  124.  
  125.     if(child.id() == fav.id()) {
  126.       // We found our fav
  127.       c_Folder.children.remove(child);
  128.     }
  129.   }
  130. }
  131. // Bubble Sorting Routine
  132. function bubbleSort(aFolderURN, aNewResource, aCompareFunction, aCoopDS) 
  133. {
  134.   var bInserted = false;
  135.  
  136.   var c_Folder = aCoopDS.get(aFolderURN);
  137.  
  138.   // Get Children of c_Folder
  139.   var childEnum = c_Folder.children.enumerate();
  140.  
  141.   // Get fav of aNewResource
  142.   aNewResource.QueryInterface(Components.interfaces.nsIRDFResource);
  143.   var newFav = aCoopDS.get_from_resource(aNewResource);
  144.  
  145.   var aTopSiteCount = 0;
  146.  
  147.   var bAlreadySeen = false;
  148.  
  149.   var iMaxCount = PREF_MYWORLD_TOPSITES_COUNT_DEFAULT;
  150.   if(PREFS.getPrefType(PREF_MYWORLD_TOPSITES_COUNT))
  151.   {
  152.     iMaxCount = PREFS.getIntPref(PREF_MYWORLD_TOPSITES_COUNT);
  153.   }
  154.   else
  155.   {
  156.     PREFS.setIntPref(PREF_MYWORLD_TOPSITES_COUNT, iMaxCount);
  157.   }
  158.  
  159.   while (childEnum.hasMoreElements()) {
  160.       
  161.     aTopSiteCount++;
  162.   
  163.     var child = childEnum.getNext();   
  164.  
  165.     // If we have NOT inserted, and this child is the same as what we want to insert
  166.     // BAIL out.
  167.     if(!bInserted && checkDupe(aFolderURN, newFav, child)) {
  168.       return;
  169.     }
  170.  
  171.     // If we have NOT inserted yet, check for an appropriate spot
  172.     if (!bInserted && (aCompareFunction(newFav,child) >= 0))
  173.     {
  174.       var aIndex = c_Folder.children.indexOf(child);
  175.  
  176.       while(c_Folder.children.has(newFav)) {
  177.         c_Folder.children.remove(newFav);
  178.       }
  179.  
  180.       c_Folder.children.insertAt(newFav,aIndex);
  181.  
  182.       bInserted = true;
  183.       break;
  184.     }
  185.   }
  186.  
  187.   // Never inserted
  188.   // no items were in the collection before OR it is the oldest item.  
  189.   // Insert only if there's room
  190.   if (!bInserted && (aTopSiteCount+1 <= iMaxCount)) {
  191.     c_Folder.children.insertAt(newFav,aTopSiteCount+1);
  192.   }
  193.  
  194.  
  195.   // Go through the list again and make sure we remove the max elements
  196.   var e = c_Folder.children.enumerate();
  197.  
  198.   var iIndex = 0;
  199.   while(e.hasMoreElements()) {
  200.     var maxchild = e.getNext();
  201.     iIndex++;
  202.  
  203.     // We're over our allotted amount.. remove!
  204.     if (iIndex > iMaxCount && maxchild) {
  205.       c_Folder.children.remove(maxchild);
  206.     } 
  207.   }
  208. }
  209.  
  210. function checkDupe(aFolderURN, newFav, child) {
  211.   switch(aFolderURN) {
  212.     case "urn:flock:topsites": {
  213.       if(newFav.URL == child.URL)
  214.         return true;
  215.     } break;
  216.     case "urn:flock:topfeeds": {
  217.       if(newFav.URL == child.URL)
  218.         return true;
  219.     } break;
  220.     case "urn:flock:topmedia": {
  221.       if(newFav.name == child.name
  222.           && newFav.service == child.service) {
  223.         return true;
  224.       }
  225.     }
  226.   }
  227.  
  228.   return false;
  229. }
  230.  
  231. function convertMonth(month) {
  232.   switch(month) {
  233.   case 'Jan': {
  234.               return 1;
  235.             }break;
  236.   case 'Feb': {
  237.               return 2;
  238.             }break;
  239.   case 'Mar': {
  240.               return 3;
  241.             }break;
  242.   case 'Apr': {
  243.               return 4;
  244.             }break;
  245.   case 'May': {
  246.               return 5;
  247.             }break;
  248.   case 'Jun': {
  249.               return 6;
  250.             }break;
  251.   case 'Jul': {
  252.               return 7;
  253.             }break;
  254.   case 'Aug': {
  255.               return 8;
  256.             }break;
  257.   case 'Sep': {
  258.               return 9;
  259.             }break;
  260.   case 'Oct': {
  261.               return 10;
  262.             }break;
  263.   case 'Nov': {
  264.               return 11;
  265.             }break;
  266.   case 'Dec': {
  267.               return 12;
  268.             }break;
  269.   }
  270.  
  271.   return 1;
  272. }
  273.  
  274.  
  275. // This data structure contains all the information we need to determine and
  276. // maintain the list of "top" faves in each of the supported categories (Sites,
  277. // Feeds, Media).  The associative array keys are URNs of the folder nodes.
  278. //  'criteria' - array of predicate-object pairs used to identify the type
  279. //  'triggers' - array of type-source-predicate-object tuples (arc property
  280. //               operations) that will trigger the observer
  281. //  'observer' - callback for triggers, refreshes folder contents
  282. //  'compare'  - function used to sort items of that type
  283. var gTopFaves = [
  284.   {
  285.     urn: "urn:flock:topsites",
  286.     criteria: [[FLRDF("flockType"), rdfLiteral("bookmark")]],
  287.     triggers: [[Ci.flockIRDFObserver.WATCH_TYPES, null, WBRDF("LastModifiedDate"), null],
  288.                [Ci.flockIRDFObserver.TYPE_ALL, null, WBRDF("LastVisitDate"), null]
  289.               ],
  290.     observer: {
  291.       rdfChanged: function (aDS, aType, aSource, aPredicate, aTarget, aOldTarget) {
  292.         
  293.         if (!aSource) return;
  294.  
  295.         aSource.QueryInterface(Ci.nsIRDFResource);
  296.  
  297.         if(aType == Ci.flockIRDFObserver.TYPE_UNASSERT) {
  298.           // Remove this from topsites
  299.           removeSite(this.ft.urn, aSource, this.svc.faves_coop);
  300.         } else {
  301.           bubbleSort(this.ft.urn, aSource, this.ft.compare, this.svc.faves_coop);
  302.         }
  303.         
  304.         var obs = getObserverService();
  305.         obs.notifyObservers(null, 'refresh-myworld-topsites', false);
  306.       }
  307.     },
  308.     compare: function (aResourceA, aResourceB) {
  309.       // Compare the two resource's timestamp
  310.       // -1 = A older than B
  311.       // 0  = equivalent
  312.       // 1  = A newer than B
  313.       return aResourceA.LastVisitDate - aResourceB.LastVisitDate;
  314.     },
  315.     initialize: function (ft,svc,coopObj)
  316.     {
  317.       if (coopObj == null) {
  318.         coopObj = Cc['@flock.com/singleton;1'].getService(Ci.flockISingleton).getSingleton('chrome://browser/content/flock/common/load-faves-coop.js').wrappedJSObject.bookmarks_root;
  319.       }
  320.       
  321.       var e = coopObj.children.enumerate();
  322.  
  323.       while (e.hasMoreElements()){
  324.         var entry = e.getNext();
  325.  
  326.         if (entry.flockType == "bookmark") {
  327.           var favResource = RDFS.GetResource(entry.id());
  328.           bubbleSort(ft.urn, favResource, ft.compare, svc.faves_coop);
  329.         } else if (entry.flockType == "folder") {
  330.           this.initialize(ft,svc,entry);
  331.         }
  332.       }
  333.     }
  334.   },
  335.   {
  336.     urn: "urn:flock:topfeeds",
  337.     criteria: [[FLRDF("flockType"), rdfLiteral("feed")]],
  338.     triggers: [[Ci.flockIRDFObserver.TYPE_ALL, null, FLRDF("datevalue"), null],
  339.                [Ci.flockIRDFObserver.TYPE_ALL, null, FLRDF("unseenItems"), null],
  340.                [Ci.flockIRDFObserver.TYPE_ALL, null, FLRDF("isPollable"), null]
  341.               ],
  342.     observer: {
  343.       rdfChanged: function (aDS, aType, aSource, aPredicate, aTarget, aOldTarget) {
  344.         
  345.         if (!aSource) return;
  346.         aSource.QueryInterface(Ci.nsIRDFResource);
  347.  
  348.         var feedObj = this.svc.faves_coop.get_from_resource(aSource);
  349.  
  350.         if ((aType == Ci.flockIRDFObserver.TYPE_UNASSERT) ||
  351.             (feedObj && feedObj.isPollable == false)) {
  352.           removeSite(this.ft.urn, aSource, this.svc.faves_coop);
  353.           return; 
  354.         }
  355.  
  356.         var sync = {  // Check if it's a feed
  357.             notify: function(timer) {
  358.               if (!checkCriteria(this.ft.criteria,aSource,this.svc.dataSource)) {
  359.                 return; 
  360.               }
  361.  
  362.               // Check parent for feed subscription
  363.               var c_Feed = this.svc.faves_coop.get_from_resource(aSource);
  364.               var parents = c_Feed.getParents();
  365.               for each (var parent in parents) {
  366.                 var node = parent;
  367.                 while (!node.isInstanceOf(this.svc.faves_coop.FeedContext)) {
  368.                   var nodeParents = node.getParents();
  369.                   if (nodeParents.length)
  370.                     node = nodeParents[0];
  371.                   else
  372.                     break;
  373.                 }
  374.                 if (node.id() == "urn:flock:feedcontext:news") {
  375.                   bubbleSort(this.ft.urn, aSource, this.ft.compare, this.svc.faves_coop);
  376.                   break;
  377.                 }
  378.               }
  379.             }
  380.           }
  381.  
  382.         sync.ft = this.ft;
  383.         sync.svc = this.svc;
  384.         try {
  385.           timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
  386.           timer.initWithCallback(sync, 5 * 1 * 50, Ci.nsITimer.TYPE_ONE_SHOT);
  387.         } catch (e) {
  388.           dump("Exception occurred in topfeeds: " + e + "\n");
  389.         }
  390.       }
  391.     },
  392.     compare: function (aResourceA, aResourceB) {
  393.       // A == newFav
  394.       return aResourceA.datevalue - aResourceB.datevalue;
  395.     },
  396.     initialize: function (ft,svc,coopObj)
  397.     {
  398.       if(coopObj == null) {
  399.         coopObj = Cc['@flock.com/singleton;1'].getService(Ci.flockISingleton).getSingleton('chrome://browser/content/flock/common/load-faves-coop.js').wrappedJSObject.get("urn:flock:feedcontext:news");
  400.       }
  401.  
  402.       // If we are still null, forget it
  403.       if(coopObj == null)
  404.         return;
  405.  
  406.       var e = coopObj.children.enumerate();
  407.  
  408.       while (e.hasMoreElements()){
  409.         var entry = e.getNext();
  410.  
  411.         var favResource = RDFS.GetResource(entry.id());
  412.  
  413.         if(entry.flockType == "feed"){
  414.           bubbleSort(ft.urn, favResource, ft.compare, svc.faves_coop);
  415.         } else if (entry.flockType == "folder") {
  416.           this.initialize(ft,svc,entry);
  417.         }
  418.       }
  419.     }
  420.   },
  421.   {
  422.     urn: "urn:flock:topmedia",
  423.     criteria: [[W3RDF("type"), NSRDF("MediaQuery")]],
  424.     triggers: [[Ci.flockIRDFObserver.TYPE_ALL, null, FLRDF("latestDate"), null]],
  425.     observer: {
  426.       rdfChanged: function (aDS, aType, aSource, aPredicate, aTarget, aOldTarget) {
  427.         
  428.         if (!aSource) return;
  429.         aSource.QueryInterface(Ci.nsIRDFResource);
  430.  
  431.         if(aType == Ci.flockIRDFObserver.TYPE_UNASSERT) {
  432.           // Don't process
  433.           return; 
  434.         }
  435.  
  436.         var sync = {  // Check if it's a media obj
  437.             notify: function(timer) {
  438.         
  439.               if (!checkCriteria(this.ft.criteria,aSource,this.svc.dataSource)) {
  440.                 return; 
  441.               }
  442.  
  443.               // Check parent for media subscription
  444.               var c_Media = this.svc.faves_coop.get_from_resource(aSource);
  445.               var parents = c_Media.getParents();
  446.               for (var i in parents) {
  447.                 var parent = parents[i];
  448.                 if (parent.id() == "urn:media:favorites") {
  449.                   bubbleSort(this.ft.urn, aSource, this.ft.compare, this.svc.faves_coop);
  450.                   break;
  451.                 }
  452.               }
  453.             }
  454.           }
  455.  
  456.         sync.ft = this.ft;
  457.         sync.svc = this.svc;
  458.  
  459.         timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
  460.         timer.initWithCallback(sync, 5 * 1 * 50, Ci.nsITimer.TYPE_ONE_SHOT);
  461.       }
  462.     },
  463.     compare: function (aResourceA, aResourceB) {
  464.       // A == newFav
  465.       return aResourceA.latestDate - aResourceB.latestDate;
  466.     },
  467.     initialize: function (ft,svc,coopObj)
  468.     {
  469.       if(coopObj == null) {
  470.         coopObj = Cc['@flock.com/singleton;1'].getService(Ci.flockISingleton).getSingleton('chrome://browser/content/flock/common/load-faves-coop.js').wrappedJSObject.get("urn:media:favorites");
  471.       }
  472.  
  473.       // If we are still null, forget it
  474.       if(coopObj == null)
  475.         return;
  476.  
  477.       var e = coopObj.children.enumerate();
  478.  
  479.       while (e.hasMoreElements()){
  480.         var entry = e.getNext();
  481.       
  482.         var favResource = RDFS.GetResource(entry.id());
  483.         // JMC - MediaQuery is no longer CountedObject
  484.         if(entry.flockType == "media"){
  485.           bubbleSort(ft.urn, favResource, ft.compare, svc.faves_coop);
  486.         } else if (entry.flockType == "folder") {
  487.           this.initialize(ft,svc,entry);
  488.         }
  489.       }
  490.     }
  491.   }
  492. ];
  493.  
  494. // checks incoming criteria for a match
  495. function checkCriteria(aCriteriaArr,aSource,aDataSource) 
  496. {
  497.   aSource.QueryInterface(Components.interfaces.nsIRDFResource);
  498.  
  499.  
  500.   for (var i=0;i<aCriteriaArr.length;i++) {
  501.     var prop = aCriteriaArr[i][0].QueryInterface(Ci.nsIRDFResource); 
  502.     var value = aCriteriaArr[i][1].QueryInterface(Ci.nsIRDFNode); 
  503.  
  504.     if(!aDataSource.HasAssertion(aSource, prop, value, true)) {
  505.       return false;
  506.     }
  507.   }
  508.  
  509.   return true;
  510. }
  511.  
  512. // Component Utils (just used for the timer/scheduler)
  513. var gCompTK;
  514. function getCompTK() {
  515.   if (!gCompTK) {
  516.     var gCompTK = Cc["@flock.com/singleton;1"]
  517.       .getService(Ci.flockISingleton)
  518.       .getSingleton("chrome://browser/content/flock/services/common/load-compTK.js")
  519.       .wrappedJSObject;
  520.   }
  521.   return gCompTK;
  522. }
  523.  
  524. function loadSubScript(spec)
  525. {
  526.   var loader = Cc["@mozilla.org/moz/jssubscript-loader;1"]
  527.     .getService(Ci.mozIJSSubScriptLoader);
  528.   var context = {};
  529.   loader.loadSubScript(spec, context);
  530.   return context;
  531. }
  532.  
  533.  
  534. // nsISimpleEnumerator implementation 
  535. function simpleEnumerator(aArray)
  536. {
  537.   aArray.hasMoreElements = function () { 
  538.     return this.length != 0; 
  539.   }
  540.   aArray.getNext = function () { 
  541.     return this.shift(); 
  542.   }
  543.   return aArray;
  544. }
  545.  
  546.  
  547. function makeNSIArray(aArray) {
  548.   aArray.queryElementAt = function (aIndex, aIIDRef) {
  549.     return aArray[aIndex].QueryInterface(aIIDRef);
  550.   }
  551.   aArray.enumerate = function () { return simpleEnumerator(this); }
  552.   aArray._indexOf = aArray.indexOf;
  553.   aArray.indexOf = function (aStartIndex, aElement) { return this._indexOf(aElement, aStartIndex); }
  554.   return aArray;
  555. }
  556.  
  557.  
  558. function getProfDirFile()
  559. {
  560.   var dirService = Cc[DIRECTORY_SVC_CONTRACTID].getService(Ci.nsIProperties);
  561.   
  562.  
  563.   // create a datasource in the profile directory
  564.   var profd = dirService.get("ProfD", Ci.nsIFile);
  565.   var file = Cc[LOCAL_FILE_CONTRACTID].createInstance(Ci.nsILocalFile);
  566.   file.initWithPath(profd.path);
  567.   return file;
  568. }
  569.  
  570.  
  571. function base64Encode(aInput) {
  572.   var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
  573.   var output = "";
  574.   while (aInput.length > 0) {
  575.     output += chars[aInput.charCodeAt(0) >> 2];
  576.     output += chars[((aInput.charCodeAt(0) & 0x03) << 4) | 
  577.       (aInput.length > 1 ? ((aInput.charCodeAt(1) & 0xF0) >> 4) : 0)];
  578.     output += chars[aInput.length > 1 ?
  579.       ((aInput.charCodeAt(1) & 0x0F) << 2) | 
  580.       (aInput.length > 2 ? ((aInput.charCodeAt(2) & 0xC0) >> 6) : 0) : 64];
  581.     output += chars[aInput.length > 2 ?
  582.       (aInput.charCodeAt(2) & 0x3F) : 64];
  583.     if (aInput.length > 3) {
  584.       aInput = aInput.substr(3);
  585.     } else {
  586.       break;
  587.     }
  588.   }
  589.   return output;
  590. }
  591.  
  592.  
  593.  
  594. // ======================================================
  595. // ========== BEGIN favoritesService Component ==========
  596. // ======================================================
  597.  
  598.  
  599. // BEGIN Constructor
  600. function favoritesService()
  601. {
  602.   this._logger = Cc["@flock.com/logger;1"].createInstance(Ci.flockILogger);
  603.   this._logger.init("favoritesService");
  604.   this._logger.info("Created Favorites Service Object");
  605.  
  606.   // JMC - Delay init until the DIRService Exists
  607.   this.loaded = false;
  608. }
  609. // END Constructor
  610.  
  611.  
  612. // BEGIN nsISupports
  613. favoritesService.prototype.QueryInterface =
  614. function (aIID)
  615. {
  616.   if ( !aIID.equals(Ci.nsIBookmarksService) && 
  617.        !aIID.equals(Ci.flockIFavoritesService) &&
  618.        !aIID.equals(Ci.flockIMigratable) &&
  619.        !aIID.equals(Ci.nsICharsetResolver) &&
  620.        !aIID.equals(Ci.nsIClassInfo) &&
  621.        !aIID.equals(Ci.nsIObserver) &&
  622.        !aIID.equals(Ci.nsISupports) )
  623.   {
  624.     throw Cr.NS_ERROR_NO_INTERFACE;
  625.   }
  626.   return this;
  627. }
  628. // END nsISupports
  629.  
  630.  
  631. // BEGIN nsIClassInfo
  632. favoritesService.prototype.flags = Ci.nsIClassInfo.SINGLETON;
  633. favoritesService.prototype.classDescription = "Flock Favorites Service";
  634. favoritesService.prototype.getInterfaces = function (count) {
  635.   var interfaceList = [ Ci.nsIBookmarksService, Ci.flockIFavoritesService,
  636.                         Ci.nsICharsetResolver,
  637.                         Ci.flockIMigratable, Ci.nsIClassInfo ];
  638.   count.value = interfaceList.length;
  639.   return interfaceList;
  640. }
  641. favoritesService.prototype.getHelperForLanguage = function (count) { return null; }
  642. // END nsIClassInfo
  643.  
  644.  
  645. // BEGIN nsIObserver
  646. favoritesService.prototype.observe = function (subject, topic, data)
  647. {
  648.   if ( topic == "nsPref:changed" &&
  649.        data == PREF_FIRSTRUN_COMPLETED &&
  650.        PREFS.getBoolPref(PREF_FIRSTRUN_COMPLETED) )
  651.   {
  652.     for (var folderURN in gTopFaves) {
  653.       var faveType = gTopFaves[folderURN];
  654.  
  655.       // start gTopFaves init function
  656.       faveType.initialize(faveType,this,null);
  657.     }
  658.  
  659.     if (!PREFS.getBoolPref(PREF_INDEXED_INITIAL_FAVORITES)) {
  660.       var index_initial_callback = {};
  661.       index_initial_callback.svc = this;
  662.       index_initial_callback.notify = function (timer) {
  663.         var e = this.svc.getAllFavorites();
  664.         while (e.hasMoreElements()) {
  665.           var u = e.getNext().QueryInterface(Ci.nsIRDFResource).ValueUTF8;
  666.           //this.svc.luceneIndexer.AddDocument(u);
  667.         }
  668.         PREFS.setBoolPref(PREF_INDEXED_INITIAL_FAVORITES, true);
  669.       }
  670.     }
  671.   }
  672.  
  673.   if (topic == "xpcom-shutdown") {
  674.     this.obs.removeObserver(this, "xpcom-shutdown");
  675.     try {
  676.       this.deleteTransients();
  677.     } catch (ex) {
  678.       this._logger.debug("ERROR deleting transient data!");
  679.       this._logger.debug(ex);
  680.     }
  681.   }
  682. }
  683. // END nsIObserver
  684.  
  685.  
  686. // BEGIN flockIFavoritesService
  687. favoritesService.prototype.setupDefaultFavorites = function ()
  688. { 
  689.   this._logger.info("SetupDefaultFavorites");
  690.   var faves_coop = this.faves_coop;
  691.   var favSrv = this;
  692.   var context = {coop: faves_coop, service: favSrv, dump: dump};
  693.   var loader = Cc["@mozilla.org/moz/jssubscript-loader;1"]
  694.     .getService(Ci.mozIJSSubScriptLoader);
  695.   loader.loadSubScript("chrome://flock/locale/favorites/defaultFavorites.js", context);
  696.   
  697.   // Load up the defaul media favs too.
  698.   loader.loadSubScript("chrome://flock/locale/photo/defaultMedia.js", context);
  699. }
  700.  
  701. favoritesService.prototype.init = 
  702. function favoritesService_init(aDataSource)
  703. {
  704.   if (this.loaded) return;
  705.  
  706.   this.dataSource = aDataSource;
  707.   aDataSource.QueryInterface(Ci.flockIRDFObservable);
  708.   this.faves_coop = Cc["@flock.com/singleton;1"]
  709.     .getService(Ci.flockISingleton)
  710.     .getSingleton("chrome://browser/content/flock/common/load-faves-coop.js")
  711.     .wrappedJSObject;
  712.  
  713.   var prefsService = Cc["@mozilla.org/preferences-service;1"]
  714.                      .getService(Ci.nsIPrefService);
  715.   var favesBranch = prefsService.getBranch("flock.favorites.");
  716.  
  717.   // Convert 0.9.0.x LastVisitDate/LastModifiedDate from strings to real dates
  718.   var migratedStringDates;
  719.   try {
  720.     migratedStringDates = favesBranch.getBoolPref("migratedStringDates");
  721.   }
  722.   catch (ex) {
  723.     migratedStringDates = false;
  724.   }
  725.  
  726.   if (!migratedStringDates) {
  727.     var inst = this;
  728.  
  729.     function convertOldDate(aResource, aProp) {
  730.       var target = inst.dataSource.GetTarget(aResource, aProp, true);
  731.       if (target && target instanceof Ci.nsIRDFLiteral) {
  732.         var dateStr = target.QueryInterface(Ci.nsIRDFLiteral).Value;
  733.         var time = Date.parse(dateStr);
  734.         if (!isNaN(time)) {
  735.           inst.dataSource.Change(aResource, aProp, target,
  736.                                  RDFS.GetDateLiteral(1000 * time));
  737.         } else {
  738.           inst.dataSource.Unassert(aResource, aProp, target);
  739.         }
  740.       }
  741.     }
  742.  
  743.     var resources = this.faves_coop.Bookmark.all_ids();
  744.     while (resources.hasMoreElements()) {
  745.       var resource = resources.getNext();
  746.       convertOldDate(resource, RDF_LASTVISITDATE);
  747.       convertOldDate(resource, RDF_LASTMODIFIEDDATE);
  748.     }
  749.  
  750.     favesBranch.setBoolPref("migratedStringDates", true);
  751.   }
  752.  
  753.   // Make sure no favorite has more than one parent (only once)
  754.   var uniqueId = false;
  755.   try {
  756.     uniqueId = favesBranch.getBoolPref("uniqueid");
  757.   } catch(e) { /* The pref is not set yet */ }
  758.   if (!uniqueId) {
  759.     for (var i in gTopFaves) {
  760.       // Change the top favorites from the Folder type to TopFavesFolder
  761.       try {
  762.         var res = RDFS.GetResource(gTopFaves[i].urn);
  763.         var oldtype = this.dataSource.GetTarget(res, W3RDF("type"), true);
  764.         var oldcooptype = this.dataSource.GetTarget(res, FLRDF("CoopType"), true);
  765.         if (oldtype)
  766.           this.dataSource.Change(res, W3RDF("type"), oldtype, FLRDF("TopFavesFolder"));
  767.         if (oldcooptype)
  768.           this.dataSource.Change(res, FLRDF("CoopType"), oldcooptype, FLRDF("TopFavesFolder"));
  769.       }
  770.       catch (e) {}
  771.     }
  772.   
  773.     var allFaves = this.faves_coop.Bookmark.all();
  774.     var nonUnique = [];
  775.     while (allFaves.hasMoreElements()) {
  776.       var fave = allFaves.getNext();
  777.       // Assuming all bookmarks with an id starting with "urn:" are online
  778.       // faves, and thus should not be transformed. 
  779.       var urn = fave.id();
  780.       if (urn.substr(0, 4) == "urn:") {
  781.         continue;
  782.       }
  783.       var parentCount = 0;
  784.       for each (var parent in fave.getParents()) {
  785.         if (parent instanceof this.faves_coop.Folder)
  786.           parentCount++;
  787.       }
  788.       if (parentCount > 1) {
  789.         nonUnique.push(fave);
  790.       }
  791.     }
  792.  
  793.     for each (var fave in nonUnique) {
  794.       // This favorite has more than one parent.
  795.       // We need to clone it so each favorite has only one parent.
  796.       var firstparent = true;
  797.       var faveRes = RDFS.GetResource(fave.id());
  798.       for each (var parent in fave.getParents()) {
  799.         if (parent instanceof this.faves_coop.Folder) {
  800.           if (firstparent) {
  801.             // The first parent keeps the original favorite
  802.             firstparent = false;
  803.           }
  804.           else {
  805.             // Other parents get a clone
  806.             var newRes = this.cloneResource(faveRes);
  807.             var newFave = this.faves_coop.get(newRes.Value);
  808.  
  809.             var position = parent.children.indexOf(fave);
  810.             parent.children.insertAt(newFave, position);
  811.             parent.children.remove(fave);
  812.           }
  813.         }
  814.         else {
  815.           // MyWorld's "Top Faves" keeps the original
  816.         }
  817.       }
  818.     }
  819.     favesBranch.setBoolPref ("uniqueid", true);
  820.   }
  821.  
  822.   for (var folderURN in gTopFaves) {
  823.     // Make sure the sorting folders exist for each type
  824.     var faveType = gTopFaves[folderURN];
  825.     faveType.observer.ft = faveType;
  826.     faveType.observer.svc = this;
  827.     faveType.root = this.faves_coop.get(faveType.urn);
  828.     if (!faveType.root) {
  829.       faveType.root = new this.faves_coop.Folder(faveType.urn);
  830.     }
  831.     // Start watching for the appropriate arc changes
  832.     for (var t in faveType.triggers) {
  833.       var trig = faveType.triggers[t];
  834.       this.dataSource.addArcObserver(trig[0], trig[1], trig[2], trig[3],
  835.                                      faveType.observer);
  836.     }
  837.   }
  838.   
  839.   this._obsObsrv = {};
  840.   this._obsObsrv.observe = function main_observer(aSubject, aTopic, aVerb) {
  841.     
  842.     if( aTopic == "myworld-enableDisable-observers" ) {
  843.       if( aVerb == "true" ) {
  844.         // Re-enable the arc observers
  845.         for (var folderURN in this.gtf) {
  846.           // Make sure the sorting folders exist for each type
  847.           var faveType = this.gtf[folderURN];
  848.           faveType.observer.ft = faveType;
  849.           faveType.observer.svc = this.svc;
  850.           faveType.root = this.fc.get(faveType.urn);
  851.           if (!faveType.root) { faveType.root = new this.fc.TopFavesFolder(faveType.urn); }
  852.           // Start watching for the appropriate arc changes
  853.           for (var t in faveType.triggers) {
  854.             var trig = faveType.triggers[t];
  855.             this.ds.addArcObserver(trig[0], trig[1], trig[2], trig[3], faveType.observer);
  856.           }
  857.         }
  858.       } else {
  859.         // remove the arc observers
  860.         for (var folderURN in this.gtf) {
  861.           // Make sure the sorting folders exist for each type
  862.           var faveType = this.gtf[folderURN];
  863.           faveType.observer.ft = faveType;
  864.           faveType.observer.svc = this.svc;
  865.           faveType.root = this.fc.get(faveType.urn);
  866.           if (!faveType.root) { faveType.root = new this.fc.TopFavesFolder(faveType.urn); }
  867.           // Start watching for the appropriate arc changes
  868.           for (var t in faveType.triggers) {
  869.             var trig = faveType.triggers[t];
  870.             this.ds.removeArcObserver(trig[0], trig[1], trig[2], trig[3], faveType.observer);
  871.           }
  872.         }
  873.       } 
  874.     }
  875.   }
  876.   this._obsObsrv.fc   = this.faves_coop;
  877.   this._obsObsrv.svc  = this;
  878.   this._obsObsrv.ds   = this.dataSource;
  879.   this._obsObsrv.gtf  = gTopFaves;
  880.     
  881.   this.obs = Cc["@mozilla.org/observer-service;1"]
  882.     .getService(Ci.nsIObserverService);
  883.     
  884.   this.obs.addObserver(this._obsObsrv, "myworld-enableDisable-observers", false);
  885.   this.obs.addObserver(this, "xpcom-shutdown", false);
  886.  
  887.   // set up a prefs observer for the webservice id
  888.   var prefBranch2 = PREFS.QueryInterface(Ci.nsIPrefBranch2);
  889.   prefBranch2.addObserver(PREF_FIRSTRUN_COMPLETED, this, false); // FIXME: removeObserver sometime?
  890.  
  891.   this.deleteTransients();
  892.   this.loaded = true;
  893.   this._logger.info("flock favorites data source set up");    
  894. }
  895.  
  896. favoritesService.prototype.createBookmarkWithTags =
  897. function (aName, aURL, aShortcutURL, aDescription, aDocCharSet, aPostData, aTags)
  898. {
  899.   var bookmark = this.createNewBookmarkWithTags(aName, aURL, aShortcutURL, aDescription,
  900.                                                 aDocCharSet, aPostData, aTags);
  901.   this.faves_coop.bookmarks_root.children.addOnce(bookmark);
  902.   return RDFS.GetResource(bookmark.id())
  903. }
  904.  
  905. favoritesService.prototype.addBookmarkToFolder =
  906. function (aFolderName, aName, aURL, aShortcutURL, aDescription, aDocCharSet, aPostData, aTags)
  907. {
  908.   var folder = this.faves_coop.get(aFolderName);
  909.   var bookmark = this.createNewBookmarkWithTags(aName, aURL, aShortcutURL, aDescription,
  910.                                                 aDocCharSet, aPostData, aTags);
  911.   folder.children.addOnce(bookmark);
  912.   return RDFS.GetResource(bookmark.id());
  913. }
  914.  
  915. favoritesService.prototype.writeBookmarks =
  916. function (aBookmarksFile)
  917. {
  918.   var bsvc = Cc["@mozilla.org/browser/bookmarks-service;1"].getService(Ci.flockIBookmarksService);
  919.   var dirService = Cc[DIRECTORY_SVC_CONTRACTID].getService(Ci.nsIProperties);
  920.   var ds = RDFS.GetDataSource("rdf:flock-favorites").QueryInterface(Ci.nsIRDFDataSource);
  921.   var resource = RDF_FOLDERSROOT;
  922.   bsvc.WriteBookmarks(aBookmarksFile, ds, resource);
  923. }
  924.  
  925. favoritesService.prototype.importBookmarks =
  926. function favoritesService_importBookmarks(aBookmarksFile)
  927. {
  928.   // Make sure the file exists and is readable
  929.   aBookmarksFile.QueryInterface(Ci.nsIFile);
  930.   if ((!aBookmarksFile.exists()) || (!aBookmarksFile.isReadable())) {
  931.     throw Cr.NS_ERROR_UNEXPECTED;
  932.   }
  933.  
  934.   // Load the contents of the file into 'lines' array
  935.   var fis = Cc["@mozilla.org/network/file-input-stream;1"]
  936.     .createInstance(Ci.nsIFileInputStream);
  937.   fis.init(aBookmarksFile, 1, 0, 0);
  938.   fis.QueryInterface(Ci.nsILineInputStream);
  939.   var lines = []; var line = {};
  940.   while (fis.readLine(line)) { lines.push(line.value); }
  941.  
  942.   // Local functions to import bookmarks and folders
  943.   var inst = this;
  944.   var decodeEntities = function (str) {
  945.     return str.replace(/</g, "<")
  946.               .replace(/>/g, ">")
  947.               .replace(/&/g, "&")
  948.               .replace(/"/g, "\"")
  949.               .replace(/'/g, "'");
  950.   };
  951.   var importBookmark = function () {
  952.     var url, lastVisit, lastMod, id, name, desc, feedurl;
  953.     if (lines[i].match(/ HREF="([^"]*)"/)) { url = RegExp.$1; }
  954.     if (lines[i].match(/ FEEDURL="([^"]*)"/)) { feedurl = RegExp.$1; }
  955.     if (lines[i].match(/ LAST_VISIT="([^"]*)"/)) { lastVisit = RegExp.$1; }
  956.     if (lines[i].match(/ LAST_MODIFIED="([^"]*)"/)) { lastMod = RegExp.$1; }
  957.     if (lines[i].match(/ ID="([^"]*)"/)) { id = RegExp.$1; }
  958.     if (lines[i].match(/">(.*)<\/A>/)) { name = decodeEntities(RegExp.$1); }
  959.     if (lines[i+1].match(/^ *<DD>(.*)$/)) { desc = decodeEntities(RegExp.$1); i++; }
  960.     var bmRes;
  961.     if (feedurl) {
  962.       bmRes = inst.createLivemark(name, url, feedurl, desc);
  963.     }
  964.     else if (url == undefined) {
  965.       bmRes = inst.createSeparator();
  966.     }
  967.     else {
  968.       bmRes = inst.createBookmarkInternal(name, url, desc, new Date(lastVisit), new Date(lastMod));
  969.     }
  970.     return inst.faves_coop.get(bmRes.Value);
  971.   };
  972.   var importFolder = function () {
  973.     lines[i++].match(/">(.*)<\/H3/i);
  974.     var folderRes = inst.createFolder(RegExp.$1);
  975.     var c_folder = inst.faves_coop.get(folderRes.Value);
  976.     inst.faves_coop.bookmarks_root.children.remove(c_folder);
  977.     if (lines[i].match(/^ *<DD>(.*)$/i)) {
  978.       c_folder.description = decodeEntities(RegExp.$1);
  979.       i++;
  980.     }
  981.     if (lines[i].match(/^ *<DL><p>/i)) {
  982.       // This folder contains stuff
  983.       importContents(c_folder);
  984.     }
  985.     return c_folder;
  986.   };
  987.   var importContents = function (aParentFolder) {
  988.     i++; // Increment past <DL><p>
  989.     while (i < lines.length) {
  990. //      inst._logger.warn("\n Parent: "+aParentFolder.Value+" line: "+lines[i]);
  991.       var child = null;
  992.       if (lines[i].match(/^ *<DT><A /i)) {
  993.         child = importBookmark();
  994.       } else if (lines[i].match(/^ *<DT><H3/i)) {
  995.         child = importFolder();
  996.       } else if (lines[i].match(/^ *<\/DL><p>/i)) {
  997.         return;
  998.       }
  999.       if (child) {
  1000.         aParentFolder.children.addOnce(child);
  1001.       }
  1002.       i++;
  1003.     }
  1004.   };
  1005.  
  1006.   // Begin parsing the file
  1007.   var i = 0;
  1008.   while ((!lines[i].match(/^ *<DL><p>/i)) && (i < lines.length)) { i++; }
  1009.   var folder = this.faves_coop.get(this.createFolder("Imported Bookmarks").Value);
  1010.   importContents(folder);
  1011. }
  1012. // END flockIFavoritesService
  1013.  
  1014.  
  1015.  
  1016. // BEGIN nsIBookmarksService
  1017. favoritesService.prototype.addBookmarkImmediately = function (aURI, aTitle, bmType, aDocCharSet) 
  1018. { 
  1019.   return this.createBookmark(aName, aURI, aURI, "", aDocCharSet, null);
  1020. }
  1021.  
  1022. favoritesService.prototype.cloneResource = function (aSource) 
  1023. {
  1024.   var newResource = RDFS.GetAnonymousResource();
  1025.  
  1026.   // We need to create CoopType first or the indexer complains
  1027.   var coopType = this.dataSource.GetTarget(aSource, RDF_COOPTYPE, true);
  1028.   if (coopType)
  1029.     this.dataSource.Assert(newResource, RDF_COOPTYPE, coopType, true);
  1030.  
  1031.   var arcs = this.dataSource.ArcLabelsOut(aSource);
  1032.  
  1033.   while (arcs.hasMoreElements()) {
  1034.     var property = arcs.getNext();
  1035.     property = property.QueryInterface(Ci.nsIRDFResource);
  1036.     if (property.EqualsNode(this.getBookmarksToolbarFolder())) continue;
  1037.     if (property.EqualsNode(RDF_COOPTYPE)) continue; // Already created
  1038.     if (property.EqualsNode(FLRDF('isIndexable'))) continue; // Will be created later
  1039.     
  1040.     var target = this.dataSource.GetTarget(aSource, property, true);
  1041.     
  1042.     // Test if the arc points to a child.
  1043.     if (RDFCU.IsOrdinalProperty(property)) {
  1044.       var oldChild = target.QueryInterface(Ci.nsIRDFResource);
  1045.       var newChild = this.cloneResource(oldChild);
  1046.       this.dataSource.Assert(newResource, property, newChild, true);
  1047.     } else {
  1048.       this.dataSource.Assert(newResource, property, target, true);
  1049.     }
  1050.   }
  1051.   
  1052.   // Create isIndexable last to avoid firing the indexer too often
  1053.   var isIndexable = this.dataSource.GetTarget(aSource, FLRDF('isIndexable'), true);
  1054.   if (isIndexable)
  1055.     this.dataSource.Assert(newResource, FLRDF('isIndexable'), isIndexable, true);
  1056.   
  1057.   return newResource;
  1058. }
  1059.  
  1060. favoritesService.prototype.createBookmark =
  1061. function (aName, aURL, aShortcutURL, aDescription, aDocCharSet, aPostData)
  1062. {
  1063.   if (!aURL || aURL == null) aURL = "about:blank";
  1064.  
  1065.   var date = new Date();
  1066.   var bookmark = new this.faves_coop.Bookmark(
  1067.    {
  1068.       name: aName,
  1069.       URL: aURL,
  1070.       description: aDescription,
  1071.       BookmarkAddDate: date,
  1072.       LastVisitDate: date
  1073.     }
  1074.   );
  1075.   return RDFS.GetResource(bookmark.id());
  1076. }
  1077.  
  1078. favoritesService.prototype.createBookmarkInternal =
  1079. function (aName, aURL, aDescription, aLastVisit, aLastMod)
  1080. {
  1081.   if (!aURL || aURL == null) aURL = "about:blank";
  1082.  
  1083.   var bookmark = new this.faves_coop.Bookmark(
  1084.      {
  1085.       name: aName,
  1086.       URL: aURL,
  1087.       description: aDescription,
  1088.       LastVisitDate: aLastVisit,
  1089.       LastModifiedDate: aLastMod
  1090.     }
  1091.   );
  1092.   return RDFS.GetResource(bookmark.id());
  1093. }
  1094.  
  1095. favoritesService.prototype.createFolder = function (aName) 
  1096. {
  1097.   if (!aName || aName == null) aName = "New Folder";
  1098.   var folder = new this.faves_coop.Folder({
  1099.     BookmarkAddDate: new Date(),
  1100.     name: aName
  1101.   });
  1102.   this.faves_coop.bookmarks_root.children.addOnce(folder);
  1103.   return RDFS.GetResource(folder.id());
  1104. }
  1105.  
  1106. favoritesService.prototype.createFolderInContainer =
  1107. function (aName, aParentFolder, aIndex)
  1108. {
  1109.   var folder = new this.faves_coop.Folder({
  1110.     BookmarkAddDate: new Date(),
  1111.     name: aName
  1112.   });
  1113.  
  1114.   // default to the favorites_root folder...
  1115.   var parent = this.faves_coop.favorites_root;
  1116.   if (aParentFolder) {
  1117.     // FIXME: get should be able to take an nsIRDFResource as an id
  1118.     parent = this.faves_coop.get(aParentFolder.ValueUTF8)
  1119.   }
  1120.   if (aIndex < 0)
  1121.     parent.children.add(folder);
  1122.   else
  1123.     parent.children.insertAt(folder, aIndex);
  1124.  
  1125.   return RDFS.GetResource(folder.id());
  1126. }
  1127.  
  1128. favoritesService.prototype.createLivemark =
  1129. function (aName, aURL, aRSSURL, aDescription)
  1130. {
  1131.   var feedService = Cc["@flock.com/feed-manager;1"].getService(Ci.flockIFeedManager);
  1132.   var livemarkContext = feedService.getFeedContext("livemarks");
  1133.   var feed = livemarkContext.getRoot().subscribeURL(aRSSURL, aName);
  1134.   return RDFS.GetResource(feed.id());
  1135. }
  1136.  
  1137. favoritesService.prototype.createLivemarkInContainer =
  1138. function FS_createLivemarkInContainer(aName, aURL, aRSSURL, aDescription, aFolder, aIndex)
  1139. {
  1140.   var feedService = Cc["@flock.com/feed-manager;1"].getService(Ci.flockIFeedManager);
  1141.   var livemarkContext = feedService.getFeedContext("livemarks");
  1142.  
  1143.   parent_ = this.faves_coop.get(aFolder.ValueUTF8)
  1144.   if (!parent_) { // Invalid folder
  1145.     throw Components.Exception('createLivemarkInContainer: invalid folder '+aFolder.ValueUTF8,
  1146.                                 Cr.NS_ERROR_UNEXPECTED);
  1147.   }
  1148.  
  1149.   var feed = livemarkContext.getRoot().subscribeURL(aRSSURL, aName);
  1150.   var coopFeed = this.faves_coop.get(feed.id());
  1151.  
  1152.   if (aIndex < 0) {
  1153.     parent_.children.add(coopFeed);
  1154.   }
  1155.   else {
  1156.     parent_.children.insertAt(coopFeed, aIndex);
  1157.   }
  1158. }
  1159.  
  1160. favoritesService.prototype.createSeparator = function ()
  1161. { 
  1162.   var newSeparator = new this.faves_coop.Separator();
  1163.   return RDFS.GetResource(newSeparator.id());
  1164. }
  1165.  
  1166. favoritesService.prototype.getBookmarksToolbarFolder = function ()
  1167. {
  1168.   if (this.faves_coop.toolbar.folder) {
  1169.     return RDFS.GetResource(this.faves_coop.toolbar.folder.id());
  1170.   } else {
  1171.     // JMC - Always have a toolbar folder
  1172.     var favesToolbar = new this.faves_coop.Folder({name: "Favorites Toolbar"});
  1173.     this.faves_coop.toolbar.folder = favesToolbar;
  1174.     this.faves_coop.bookmarks_root.children.addOnce(this.faves_coop.toolbar.folder);
  1175.     return this.getBookmarksToolbarFolder();
  1176.   }
  1177. }
  1178.  
  1179. favoritesService.prototype.getLastCharset = function (aURL) { return null; }
  1180.  
  1181. favoritesService.prototype.getParent = function (aSource) 
  1182. { 
  1183.   if (!aSource || !aSource.QueryInterface || !aSource.QueryInterface(Ci.nsIRDFNode)) return false;
  1184.  
  1185.   var arcs = this.dataSource.ArcLabelsIn(aSource);
  1186.   while (arcs && arcs.hasMoreElements()) {
  1187.     var resource = arcs.getNext();
  1188.     if (resource && resource.QueryInterface) {
  1189.       resource = resource.QueryInterface(Ci.nsIRDFResource);
  1190.     }
  1191.     if (resource && resource.QueryInterface && RDFCU.IsOrdinalProperty(resource)) {
  1192.       var parent = this.dataSource.GetSource(resource, aSource, true);
  1193.       return parent;
  1194.     }
  1195.   }
  1196.   return null;
  1197. }
  1198.  
  1199. favoritesService.prototype.getParentChain = function (aSource) 
  1200. { 
  1201.   var chain = [];
  1202.   var current = this.getParent(aSource);
  1203.   while (current) {
  1204.     this._logger.info("parentChain: "+current);
  1205.     chain.push(current);
  1206.     current = this.getParent(current);
  1207.   }
  1208.   chain.reverse();
  1209.   return makeNSIArray(chain); 
  1210. }
  1211.  
  1212. favoritesService.prototype.isBookmarked = function (aURL)
  1213. {
  1214.   return this.faves_coop.Bookmark.get_from_url(aURL) != null;
  1215. }
  1216.  
  1217. favoritesService.prototype.isBookmarkedResource = function (aResource)
  1218. {
  1219.   return this.faves_coop.Bookmark.exists(aResource.Value);
  1220. }
  1221.  
  1222. favoritesService.prototype.readBookmarks = function () { return; }
  1223.  
  1224. favoritesService.prototype.removeBookmarkIcon = function (aURL) { return; }
  1225.  
  1226. favoritesService.prototype.resolveKeyword = function (aName, aPostData) 
  1227. {
  1228.   var keywordArray = this.faves_coop.Bookmark.find({ShortcutURL: aName})
  1229.   var keyword = null;
  1230.   if (keywordArray && keywordArray.length == 1) {
  1231.     keyword = keywordArray[0].URL;
  1232.   }
  1233.   return keyword; 
  1234. }
  1235.  
  1236. favoritesService.prototype.updateBookmarkIcon =
  1237. function (aURL, aIconMIMEtype, aIconData, aIconDataLen) 
  1238. {
  1239.   var data = "data:";
  1240.   if (aIconData) {
  1241.     iconData = String.fromCharCode.apply(null, aIconData);
  1242.     data += aIconMIMEtype;
  1243.     data += ";base64,";
  1244.     data += base64Encode(iconData);
  1245.   }
  1246.  
  1247.   var faves = this.faves_coop.Bookmark.find({URL: aURL});
  1248.   for (var i = 0; i < faves.length; i++) {
  1249.     var fav = faves[i];
  1250.     fav.favicon = data;
  1251.   }
  1252.   return;
  1253. }
  1254.  
  1255. favoritesService.prototype.updateLastVisitedDate = function (aURL, docCharset) {
  1256.   if (aURL == '') return;
  1257.  
  1258.   var literal = RDFS.GetLiteral(aURL);
  1259.   var sources = this.dataSource.GetSources(RDF_URL, literal, true);
  1260.   var bookmark = null;
  1261.   while (sources && sources.hasMoreElements()) {
  1262.     var source = sources.getNext().QueryInterface(Ci.nsIRDFResource);
  1263.  
  1264.     var ctRes = this.dataSource.GetTarget(source, FLRDF("CoopType"), true);
  1265.     if (ctRes) {
  1266.       ctRes.QueryInterface(Ci.nsIRDFResource);
  1267.       if (ctRes.Value == "http://flock.com/rdf#Bookmark") {
  1268.         bookmark = this.faves_coop.get_from_resource(source);
  1269.         break;
  1270.       }
  1271.     }
  1272.   }
  1273.  
  1274.   if (bookmark) {
  1275.     bookmark.LastVisitDate = new Date();
  1276.   }
  1277.   return;
  1278. }
  1279.  
  1280.  
  1281. //check if string is an integer
  1282. favoritesService.prototype.isInt = function (str) {
  1283.     var i = parseInt (str);
  1284.  
  1285.     if (isNaN (i))
  1286.         return false;
  1287.  
  1288.     i = i . toString ();
  1289.     if (i != str)
  1290.         return false;
  1291.  
  1292.     return true;
  1293. }
  1294. // END nsIBookmarksService
  1295.  
  1296.  
  1297.  
  1298. // BEGIN flockIMigratable
  1299. favoritesService.prototype.needsMigration =
  1300. function favoritesService_needsMigration(oldVersion)
  1301. {
  1302.   var oldFavoritesFile = Cc["@mozilla.org/file/directory_service;1"] 
  1303.     .getService(Ci.nsIProperties).get("ProfD", Ci.nsIFile);
  1304.   oldFavoritesFile.append(OLD_FAVORITES_RDF_FILE);
  1305.  
  1306.   var relicFavoritesFile = Cc["@mozilla.org/file/directory_service;1"] 
  1307.     .getService(Ci.nsIProperties).get("ProfD", Ci.nsIFile);
  1308.   relicFavoritesFile.append(OLD_FAVORITES_RDF_FILE_RELIC);
  1309.  
  1310.   // only migrate if the old favorites rdf file exists
  1311.   // FIXME: after the flock_favorites.rdf file is renamed to flock_favorites_old.rdf
  1312.   // flock_favorites.rdf is created again in the same dir. so we need the 2nd
  1313.   // condition in the IF to stop migration from happening again
  1314.   if (oldFavoritesFile.exists() && !relicFavoritesFile.exists()) {
  1315.     return true;
  1316.   }
  1317.   return false;
  1318. }
  1319.  
  1320. favoritesService.prototype.startMigration = 
  1321. function (oldVersion, aFlockMigrationProgressListener)
  1322. {
  1323.   // Tell myworld to stop observing.
  1324.   var obs = getObserverService();
  1325.   obs.notifyObservers(null, 'myworld-enableDisable-observers', false);
  1326.   
  1327.   var oldFavoritesFile = Cc["@mozilla.org/file/directory_service;1"] 
  1328.     .getService(Ci.nsIProperties).get("ProfD", Ci.nsIFile);
  1329.   oldFavoritesFile.append(OLD_FAVORITES_RDF_FILE);
  1330.  
  1331.   var ctxt = {
  1332.     listener: aFlockMigrationProgressListener,
  1333.     oldFavoritesFile: oldFavoritesFile
  1334.   };
  1335.  
  1336.   if (oldFavoritesFile.exists()) {
  1337.     ctxt.listener.onUpdate(0, 'Migrating favorites');
  1338.   }
  1339.   return { wrappedJSObject: ctxt };
  1340. }
  1341.  
  1342. favoritesService.prototype.doMigrationWork =
  1343. function (ctxtWrapper)
  1344. {
  1345.   var ctxt = ctxtWrapper.wrappedJSObject;
  1346.  
  1347.   if (!ctxt.oldFavoritesFile.exists())
  1348.     return false;
  1349.  
  1350.   if (!ctxt.favoritesMigrator)
  1351.     ctxt.favoritesMigrator = this._migrateFavorites(ctxt);
  1352.   if (ctxt.favoritesMigrator.next())
  1353.     ctxt.favoritesMigrator = null;
  1354.  
  1355.   return Boolean(ctxt.favoritesMigrator);
  1356. }
  1357.  
  1358. favoritesService.prototype.finishMigration = function (ctxtWrapper) { 
  1359.   // Re-init the topfaves
  1360.   for (var folderURN in gTopFaves) {
  1361.     var faveType = gTopFaves[folderURN];
  1362.  
  1363.     // start gTopFaves init function
  1364.     faveType.initialize(faveType,this,null);
  1365.   }  
  1366.   
  1367.   // Tell myworld to resume rdf observation
  1368.   var obs = getObserverService();
  1369.   obs.notifyObservers(null, 'myworld-enableDisable-observers', true);
  1370. }
  1371. // END flockIMigratable
  1372.  
  1373.  
  1374. favoritesService.prototype.deleteTransients =
  1375. function favoritesService_deleteTransients()
  1376. {
  1377.   this._logger.info(".deleteTransients()");
  1378.   var types = ["Account", "Notification", "OnlineBookmarksStream", "MediaQuery"];
  1379.   for (var t in types) {
  1380.     var type = types[t];
  1381.     this._logger.info(" deleting transients of type '"+type+"'");
  1382.     var transientArray = this.faves_coop[type].find({isTransient: true});
  1383.     for (var i = 0; i < transientArray.length; i++) {
  1384.       var transient_ = transientArray[i];
  1385.       this._logger.info('gonna remove transient named ' + transient_.name);
  1386.       var transientParents = transient_.getParents();
  1387.       for (var j = 0; j < transientParents.length; j++) {
  1388.         transientParents[j].children.remove(transient_);
  1389.       }
  1390.       if (transient_.children) {
  1391.         var childEnum = transient_.children.enumerate();
  1392.         while (childEnum.hasMoreElements()) {
  1393.           var child = childEnum.getNext();
  1394.           transient_.children.remove(child);
  1395.           if (!child.getParent()) child.destroy(); 
  1396.         }
  1397.       }
  1398.       transient_.destroy();
  1399.     }
  1400.   }
  1401. }  
  1402.  
  1403. favoritesService.prototype.Seq = function (node) {
  1404.   // make the resource a sequence if its not and return a container object
  1405.   if (!this.isSeq(node)) {
  1406.     return RDFCU.MakeSeq(this.dataSource, node);
  1407.   }
  1408.   var container = Cc[CONTAINER_CONTRACTID].createInstance(Ci.nsIRDFContainer);
  1409.   container.Init(this.dataSource, node);
  1410.   return container;
  1411. }
  1412.  
  1413. favoritesService.prototype._Seq = favoritesService.prototype.Seq;
  1414.  
  1415. favoritesService.prototype.isSeq = function (node) {
  1416.   // this._logger.info ("Called isSeq with node " + node + "\n");
  1417.   // is the node a sequence
  1418.   return RDFCU.IsSeq(this.dataSource, node);
  1419. }
  1420.  
  1421.  
  1422. favoritesService.prototype.getContainedActions = function (aURL)
  1423. {
  1424.   return simpleEnumerator(this._getContainedActions(aURL, null));
  1425. }
  1426.  
  1427. favoritesService.prototype._getContainedActions =
  1428. function (aURL, aArrIdentityActions)
  1429. {
  1430.   var getIdentityActions = function (aIdentity, identityActions) {
  1431.     var enabledActions = aIdentity.enabledAction.enumerate();
  1432.     while (enabledActions.hasMoreElements()) {
  1433.       var action = enabledActions.getNext();
  1434.       this._logger.info("adding action " + action.name + " to identityActions ");
  1435.       identityActions.push({action: action, actionName: action.name, identity: aIdentity});
  1436.     }
  1437.   };
  1438.   if (!aArrIdentityActions) {
  1439.     aArrIdentityActions = [];
  1440.   }
  1441.   var container = this.faves_coop.get(aURL);
  1442.   if (container instanceof this.faves_coop.Folder) {
  1443.     // Recurse for each contained Person
  1444.     var persons = container.children.enumerate();
  1445.     while (persons.hasMoreElements()) {
  1446.       this._getContainedActions(aChild.id(), aArrIdentityActions);
  1447.     }
  1448.   }
  1449.   if (container instanceof this.faves_coop.Person) {
  1450.     var identities = container.children.enumerate();
  1451.     while (identities.hasMoreElements()) {
  1452.       var identity = identities.getNext();
  1453.       getIdentityActions(identity, aArrIdentityActions);
  1454.     }
  1455.   }
  1456.   // return an enumerator of actions?
  1457.   return aArrIdentityActions;
  1458. }
  1459.  
  1460. favoritesService.prototype.createSeparatorInContainer =
  1461. function (aParentFolder, aIndex)
  1462. {
  1463.   var parentFolder = this.faves_coop.get_from_resource(aParentFolder);
  1464.   if (parentFolder instanceof this.faves_coop.Stream) throw NS_RDF_ASSERTION_REJECTED;
  1465.   var newSeparator = new this.faves_coop.Separator();
  1466.   parentFolder.children.insertAt(newSeparator, aIndex);
  1467.   return RDFS.GetResource(newSeparator.id());
  1468. }
  1469.  
  1470.  
  1471. favoritesService.prototype.createNewBookmarkWithTags =
  1472. function (aName, aURL, aShortcutURL, aDescription, aDocCharSet, aPostData, aTags)
  1473. {
  1474.   var now = new Date();
  1475.   
  1476.   if (!aURL || aURL == null) aURL = "about:blank";
  1477.  
  1478.   var shared = false;
  1479.   if ( PREFS.getPrefType("flock.bookmarks.shouldnotshare") &&
  1480.        PREFS.getBoolPref("flock.bookmarks.shouldnotshare") == false )
  1481.   {
  1482.     shared = true;
  1483.   }
  1484.   return new this.faves_coop.Bookmark(
  1485.       {
  1486.       name: aName,
  1487.       URL: aURL,
  1488.       description: aDescription,
  1489.       tags: aTags,
  1490.       shared: shared,
  1491.       ShortcutURL: aShortcutURL,
  1492.       BookmarkAddDate: now,
  1493.       LastModifiedDate: now,
  1494.       LastVisitDate: now,
  1495.       LastCharset: aDocCharSet
  1496.     }
  1497.   );
  1498. }
  1499.  
  1500. favoritesService.prototype.setBookmarksToolbarFolder = function (aSource)
  1501. {
  1502.   var folder = this.faves_coop.get_from_resource(aSource);
  1503.   if (folder) {
  1504.     this.faves_coop.toolbar.folder = folder;
  1505.   }
  1506. }
  1507.  
  1508. favoritesService.prototype.removeFolder = function (aFolder)
  1509. {
  1510.   // verify the folderness
  1511.   if (!this.isFolderResource(aFolder)) {
  1512.     return false;
  1513.   }
  1514.   return true;
  1515.   // FIXME: remove all the children
  1516.   // FIXME: gc the children as they're removed
  1517.   // FIXME: remove the name and the type
  1518.   // FIXME: remove the Seq-ness
  1519.   // FIXME: remove the folder from it's parent
  1520.   // FIXME: return success
  1521. }
  1522.  
  1523. favoritesService.prototype.renameFolder =
  1524. function (aFolder, aNewName)
  1525. {
  1526.   // verify the folderness
  1527.   if (!this.isFolderResource(aFolder)) {
  1528.     return false;
  1529.   }
  1530.   return true;
  1531.   // FIXME: get the old name...
  1532.   // FIXME: ds.Change RDF_NAME
  1533.   // FIXME: return success
  1534. }
  1535.  
  1536. favoritesService.prototype.moveFolder =
  1537. function (aFolder, aNewParent)
  1538. {
  1539.   // verify the folderness
  1540.   if (!this.isFolderResource(aFolder)) {
  1541.       return false;
  1542.   }
  1543.   var folder = this.faves_coop.get(aFolder.ValueUTF8);
  1544.   var newparent = this.faves_coop.favorites_root;
  1545.   if (aNewParent != null) {
  1546.     newparent = this.faves_coop.get(aNewParent.ValueUTF8);
  1547.   }
  1548.   return true;
  1549.   // FIXME: get old parent folder
  1550.   // FIXME: remove from old parent folder
  1551.   // FIXME: add to new parent folder
  1552.   // FIXME: return success
  1553. }
  1554.  
  1555. favoritesService.prototype.getFolderName = function (aFolder)
  1556. {
  1557.   // verify the folderness
  1558.   if (!this.isFolderResource(aFolder)) {
  1559.     return null;
  1560.   }
  1561.   var folder = this.faves_coop.get(aFolder.ValueUTF8);
  1562.   return folder.name;
  1563. }
  1564.  
  1565. favoritesService.prototype.createBookmarkInContainer =
  1566. function (aName, aURL, aShortcutURL, aDescription, aDocCharSet, aPostData, aFolder, aIndex)
  1567. {
  1568.   var bookmarkResource = this.createBookmark(aName, aURL, aShortcutURL, aDescription, aDocCharSet, aPostData);
  1569.   var bookmark = this.faves_coop.get(bookmarkResource.Value);
  1570.   var folder = this.faves_coop.get(aFolder.ValueUTF8);
  1571.  
  1572.   // FIXME: use index?
  1573.   folder.children.add(bookmark);
  1574.  
  1575.   //??? this.removeFavoriteFromFolder(aURL, this.favoritesRoot);
  1576. }
  1577.  
  1578. favoritesService.prototype.__defineGetter__('shortname', function () {
  1579.   return "Bookmarks";
  1580. });
  1581.  
  1582. favoritesService.prototype._migrateFavorites = function (ctxt)
  1583. {
  1584.   // a coop version of the bookmarks_root folder
  1585.   var realBookmarksRootFolder = this.faves_coop.bookmarks_root.children;
  1586.   // read into in-memory rdf
  1587.   var ds = RDFS.GetDataSourceBlocking(IOS.newFileURI(ctxt.oldFavoritesFile).spec);
  1588.   // coopify the rdf graph
  1589.   var resourceCount = 0;
  1590.   var resources = ds.GetAllResources();
  1591.  
  1592.   // helper function
  1593.   function _addBookmarkToFolderHelper(aScope, aFolder, aFav) {
  1594.     aScope.addBookmarkToFolder(aFolder, aFav.Name, aFav.URL, null,
  1595.                                aFav.description, null, null, aFav.tags);
  1596.   }
  1597.  
  1598.   while (resources.hasMoreElements()) {
  1599.     var resource = resources.getNext();
  1600.     var type_target = ds.GetTarget(resource, RDF_TYPE, true);
  1601.     if (type_target) {
  1602.       ds.Assert(resource, RDF_COOPTYPE, type_target, true);
  1603.       resourceCount++;
  1604.     }
  1605.   }
  1606.   var Coop = loadSubScript("chrome://browser/content/flock/common/coop.js").Coop;
  1607.   var migration_coop = new Coop(ds, "chrome://browser/content/flock/common/migration-coop.js");
  1608.   var folderRes;
  1609.   var favEnum = migration_coop.CardinalFavorite.all();
  1610.   var favesCount = 0;
  1611.   var folderID = this.faves_coop.bookmarks_root.id();
  1612.   while (favEnum.hasMoreElements()) {
  1613.     var fave = favEnum.getNext();
  1614.     if (!fave.Name) continue;
  1615.     if (fave.URL == "http://flock.com/rdf#FavoritesRoot") continue;
  1616.     var favParents = fave.getParents();
  1617.     if (favParents) {
  1618.       // fave.getParents() possibly has an array of null parents. These are
  1619.       // the bookmarks that are not put into a collection or bookmarks toolbar
  1620.       // in Cardinal. If there is only 1 entry in array, we need to add
  1621.       // that bookmark to the bookmarks root.
  1622.       if (favParents.length == 1 && !favParents[0]) {
  1623.         _addBookmarkToFolderHelper(this, folderID, fave);
  1624.       }
  1625.     }
  1626.     favesCount++;
  1627.     var percentage = Math.round(100 * (favesCount / resourceCount));
  1628.     ctxt.listener.onUpdate(percentage, "Migrating favorites");
  1629.     yield false;
  1630.   }
  1631.  
  1632.   // migrate collections
  1633.   var collEnum = migration_coop.CardinalCollection.all();
  1634.   var folderRes = RDFS.GetResource(this.faves_coop.bookmarks_root.id());
  1635.   while (collEnum.hasMoreElements()) {
  1636.     var coll = collEnum.getNext();
  1637.     var folderIndex = -1;
  1638.     if (!coll) {
  1639.       // We have to do this since anything that doesn't match the
  1640.       // migrations-coop schema is returned as null.
  1641.       continue;
  1642.     }
  1643.     if (!coll.Name) {
  1644.       continue;
  1645.     }
  1646.     if (coll.toolbar) {
  1647.       folderIndex = 1;
  1648.     }
  1649.     var folder = this.createFolderInContainer(coll.Name, folderRes, folderIndex);
  1650.     var collContents = coll.children.enumerate();
  1651.     while (collContents.hasMoreElements()) {
  1652.       fave = collContents.getNext();
  1653.       if (!fave) {
  1654.         // We have to do this since anything that doesn't match the
  1655.         // migrations-coop schema is returned as null.
  1656.         continue;
  1657.       }
  1658.       // Add bookmark into new folder from collection in Cardinal.
  1659.       _addBookmarkToFolderHelper(this, folder.ValueUTF8, fave);
  1660.     }
  1661.     if (coll.toolbar) {
  1662.       // Get the new folder's coop representation.
  1663.       var newFolder = this.faves_coop.get(folder.ValueUTF8);
  1664.       
  1665.       // get the bm toolbar folder name from Cormorant
  1666.       var bmToolbarId = this.getBookmarksToolbarFolder().Value;
  1667.       var bmToolbarName = this.faves_coop.get(bmToolbarId).name;
  1668.  
  1669.       // delete the default bookmark toolbar folder
  1670.       this.faves_coop.get(bmToolbarId).destroy();
  1671.  
  1672.       this.faves_coop.toolbar.folder = newFolder;
  1673.       
  1674.       // Change the toolbar folder name to Cormorant's folder name.
  1675.       this.faves_coop.toolbar.folder.name = bmToolbarName;
  1676.     }
  1677.   }
  1678.  
  1679.   // rename the file and delete the old copy
  1680.   RDFS.UnregisterDataSource(ds);
  1681.   ds = null;
  1682.   migration_coop.datasource = null;
  1683.   migration_coop = null;
  1684.   
  1685.   ctxt.oldFavoritesFile.moveTo(null, OLD_FAVORITES_RDF_FILE_RELIC);
  1686.   yield true;
  1687. }
  1688.  
  1689.  
  1690. favoritesService.prototype.notifyResolvedCharset =
  1691. function FS_notifyResolvedCharset (aCharset, aClosure) {
  1692.   throw Components.Exception("Unexpected call to NotifyResolvedCharset -- we never set aWantCharset to true!",
  1693.                              Cr.NS_ERROR_UNEXPECTED);
  1694. }
  1695.  
  1696. favoritesService.prototype.requestCharset =
  1697. function FS_requestCharset (aWebNavigation, aChannel, aWantCharset, aClosure) {
  1698.   aWantCharset = false;
  1699.   aClosure = null;
  1700.   
  1701.   var url = aChannel.URI.spec;
  1702.  
  1703.   var fav = this.faves_coop.get(url);
  1704.   if (!fav)
  1705.     return null;
  1706.   
  1707.   if (fav.LastCharset && fav.LastCharset != "")
  1708.     return fav.LastCharset;
  1709. }
  1710.  
  1711.  
  1712. // ================================================
  1713. // ========== BEGIN XPCOM Module support ==========
  1714. // ================================================
  1715.  
  1716. function createModule(aParams) {
  1717.   return {
  1718.     registerSelf: function (aCompMgr, aFileSpec, aLocation, aType) {
  1719.       var aCompMgr = aCompMgr.QueryInterface(Ci.nsIComponentRegistrar);
  1720.       aCompMgr.registerFactoryLocation( aParams.CID, aParams.componentName,
  1721.                                         aParams.contractID, aFileSpec,
  1722.                                         aLocation, aType );
  1723.       aCompMgr.registerFactoryLocation( aParams.CID, aParams.componentName,
  1724.                                         "@mozilla.org/embeddor.implemented/bookmark-charset-resolver;1", aFileSpec,
  1725.                                         aLocation, aType );
  1726.       var catMgr = Cc["@mozilla.org/categorymanager;1"]
  1727.         .getService(Ci.nsICategoryManager);
  1728.       if (!aParams.categories) { aParams.categories = []; }
  1729.       for (var i = 0; i < aParams.categories.length; i++) {
  1730.         var cat = aParams.categories[i];
  1731.         catMgr.addCategoryEntry( cat.category, cat.entry,
  1732.                                  cat.value, true, true );
  1733.       }
  1734.     },
  1735.     getClassObject: function (aCompMgr, aCID, aIID) {
  1736.       if (!aCID.equals(aParams.CID)) { throw Cr.NS_ERROR_NO_INTERFACE; }
  1737.       if (!aIID.equals(Ci.nsIFactory)) { throw Cr.NS_ERROR_NOT_IMPLEMENTED; }
  1738.       return { // Factory
  1739.         createInstance: function (aOuter, aIID) {
  1740.           if (aOuter != null) { throw Cr.NS_ERROR_NO_AGGREGATION; }
  1741.           var comp = new aParams.componentClass();
  1742.           if (aParams.implementationFunc) { aParams.implementationFunc(comp); }
  1743.           return comp.QueryInterface(aIID);
  1744.         }
  1745.       };
  1746.     },
  1747.     canUnload: function (aCompMgr) { return true; }
  1748.   };
  1749. }
  1750.  
  1751. // NS Module entrypoint
  1752. function NSGetModule(aCompMgr, aFileSpec) {
  1753.   return createModule({
  1754.     componentClass: favoritesService,
  1755.     CID: FAVORITES_CID,
  1756.     contractID: FAVORITES_CONTRACTID,
  1757.     componentName: "Favorites JS Component",
  1758.     categories: [
  1759.       { category: "flockMigratable", entry: "favorites", value: FAVORITES_CONTRACTID }
  1760.     ]
  1761.   });
  1762.  
  1763. }
  1764.  
  1765. // ========== END XPCOM Module support ==========
  1766.